package service

import (
	"fmt"
	"software/global"
	"software/models"
	"software/models/Response"
	"strconv"
	"time"
)

/**
 * 查询所有用户的个数
 */
func QueryAllUsersCount() (int64, error) {
	var count int64
	// 排除状态为4（软删除）的用户
	err := global.DB.Model(&models.User{}).Where("status != ?", 4).Count(&count).Error
	if err != nil {
		global.Log.Errorf("查询用户个数失败: %v", err)
		return 0, err
	}
	return count, nil
}

/**
 * 查询被封禁的用户状态
 */
func QueryUserBanned() ([]models.User, error) {
	var users []models.User
	err := global.DB.Where("status = ?", 1).Find(&users).Error
	if err != nil {
		global.Log.Errorf("查询用户封禁状态失败: %v", err)
		return nil, err
	}
	return users, nil
}

/**
 * 查询最新注册的用户
 */

func QueryUserByNew() ([]Response.UserResponse, error) {
	var users []models.User
	// 排除状态为4（软删除）的用户
	err := global.DB.Where("status != ?", 4).Order("register_time desc").Limit(5).Find(&users).Error
	if err != nil {
		global.Log.Errorf("查询用户失败: %v", err)
		return nil, err
	}

	// 映射到新的结构体，只包含需要的字段
	var result []Response.UserResponse
	for _, user := range users {
		result = append(result, Response.UserResponse{
			ID:           user.ID,
			Status:       user.Status,
			Nickname:     user.Nickname,
			Phone:        user.Phone,
			Email:        user.Email,
			RegisterTime: user.RegisterTime,
			Avatar:       user.Avatar,
		})
	}

	return result, nil
}

// BanUserById 根据ID封禁用户
func BanUserById(id int8, days int) error {
	var updates map[string]interface{}

	if days == -1 {
		// 永久封禁
		updates = map[string]interface{}{
			"BanTime": nil,
			"Status":  -1, // 更新状态为封禁
		}
	} else if days > 0 {
		// 临时封禁
		loc, err := time.LoadLocation("Asia/Shanghai")
		if err != nil {
			return fmt.Errorf("加载时区失败: %v", err)
		}
		now := time.Now().In(loc)
		// global.Log.Infof("当前时间: %v", now)
		bantime := now.Add(time.Duration(days) * 24 * time.Hour)
		//global.Log.Infof("bantime时间: %v", bantime)
		updates = map[string]interface{}{
			"BanTime": bantime,
			"Status":  1, // 更新状态为封禁
		}
	} else {
		return fmt.Errorf("封禁天数无效")
	}

	// 更新数据库
	result := global.DB.Model(&models.User{}).Where("id = ?", id).Updates(updates)
	return result.Error
}

func UnbanUserById(id int8) error {
	// 创建更新条件
	updates := map[string]interface{}{
		"BanTime": nil,
		"Status":  0, // 恢复状态为正常
	}

	// 更新数据库
	result := global.DB.Model(&models.User{}).Where("id = ?", id).Updates(updates)
	return result.Error
}

func QueryUserList(page int, pageSize int, keyword string, status string) ([]map[string]interface{}, int64, error) {
	var total int64
	var users []models.User

	// 创建查询构建器
	query := global.DB.Model(&models.User{})

	// 默认排除状态为4（软删除）的用户
	query = query.Where("status != ?", 4)

	// 如果有关键词，添加模糊搜索条件
	if keyword != "" {
		query = query.Where("nickname LIKE ? OR phone LIKE ? OR email LIKE ?", "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%")
	}

	// 处理状态筛选
	if status != "" {
		statusInt, err := strconv.Atoi(status)
		if err == nil {
			// 状态：0-正常，1-临时封禁，-1-永久封禁，2-注销
			query = query.Where("status = ?", statusInt)
		}
	}

	// 获取总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := query.Offset(offset).Limit(pageSize).Order("id asc").Find(&users).Error; err != nil {
		return nil, 0, err
	}

	// 构建响应数据
	var result []map[string]interface{}
	for _, user := range users {
		// 查询用户的图片
		var photos []models.Photo
		if err := global.DB.Where("user_id = ?", user.ID).Find(&photos).Error; err != nil {
			return nil, 0, err
		}

		// 计算剩余封禁时间
		var remainingBanTime string
		if user.Status == 1 && !user.BanTime.IsZero() { // 只有临时封禁才计算剩余时间
			if time.Now().Before(user.BanTime) {
				duration := user.BanTime.Sub(time.Now())
				remainingBanTime = fmt.Sprintf("%.1f天", duration.Hours()/24)
			}
		}

		// 获取状态描述
		var statusDesc string
		switch user.Status {
		case 0:
			statusDesc = "正常"
		case 1:
			statusDesc = "临时封禁"
		case -1:
			statusDesc = "永久封禁"
		case 2:
			statusDesc = "已注销"
		case 4:
			statusDesc = "已删除"
		default:
			statusDesc = "未知状态"
		}

		item := map[string]interface{}{
			"id":                 user.ID,
			"avatar":             user.Avatar,
			"nickname":           user.Nickname,
			"phone":              user.Phone,
			"email":              user.Email,
			"register_time":      user.RegisterTime,
			"status":             user.Status,
			"status_desc":        statusDesc,
			"signature":          user.Signature,
			"ban_time":           user.BanTime,
			"remaining_ban_time": remainingBanTime,
			"photos":             photos,
		}
		result = append(result, item)
	}

	return result, total, nil
}

// DeleteUserById 删除指定 ID 的用户
func DeleteUserById(userId uint) error {
	var user models.User
	result := global.DB.Where("id = ?", userId).First(&user)
	if result.Error != nil {
		return fmt.Errorf("未找到该用户")
	}

	// 执行删除操作
	return global.DB.Delete(&user).Error
}

// SoftDeleteUserById 软删除用户（将状态设为4）
func SoftDeleteUserById(userId uint) error {
	// 首先检查用户是否存在
	var user models.User
	result := global.DB.Where("id = ?", userId).First(&user)
	if result.Error != nil {
		return fmt.Errorf("未找到该用户")
	}

	// 执行软删除操作（更新状态为4）
	updates := map[string]interface{}{
		"Status": 4, // 用户状态设置为4表示软删除
	}

	updateResult := global.DB.Model(&models.User{}).Where("id = ?", userId).Updates(updates)
	if updateResult.Error != nil {
		return fmt.Errorf("软删除用户失败: %v", updateResult.Error)
	}

	return nil
}
